import java.util.HashMap;
import java.util.LinkedList;
import java.util.Scanner;

/**
 * Created with IntelliJ IDEA.
 * Description: 01游戏
 * User: DELL
 * Date: 2024-05-09
 * Time: 16:22
 */
public class Main7 {
    static int N; // 棋盘大小·
    static char[][] board; // 棋盘
    static int[] status; // dfs过程中记录每一行的状态
    static LinkedList<Integer>[] lists; // 存储每一行的所有可能状态
    static HashMap<Integer, Integer> map = new HashMap<>(); // 行状态去重

    /**
     * 总体上本题的思路基本上就是暴力，暴力的过程中利用int类型的数字来压缩每一行的状态
     * 之后利用按位操作来判断连续的情况，同时利用判断提前来进行剪枝，尽量剪枝即可。
     *
     * @param args
     */
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        N = scanner.nextInt();
        board = new char[N][N];
        for (int i = 0; i < N; i++) {
            board[i] = scanner.next().toCharArray();
        }
        status = new int[N];
        // 先将每一行的所有可能情况缓存
        lists = new LinkedList[N];
        for (int i = 0; i < N; i++) {
            lists[i] = new LinkedList<>();
            getAllDfs(lists[i], 0, 0, 0, 0, i);
        }
        dfs(0);
        // 打印
        for (int i = 0; i < N; i++) {
            int temp = status[i];
            for (int j = N - 1; j >= 0; j--) {
                if ((temp & (1 << j)) != 0) {
                    System.out.print('1');
                } else {
                    System.out.print('0');
                }
            }
            System.out.println();
        }
    }

    private static boolean dfs(int row) {
        if (row >= 3) {
            // 三个连续 1
            if ((status[row - 1] & status[row - 2] & status[row - 3]) != 0) {
                return false;
            }
            // 三个连续 0
            if ((status[row - 1] | status[row - 2] | status[row - 3]) != (1 << N) - 1) {
                return false;
            }
        }
        if (row == N) {
            return checkCol();
        }
        // 遍历每一种可能的行状态
        for (int num : lists[row]) {
            // 和前面行不同
            if (map.containsKey(num)) {
                continue;
            }
            status[row] = num;
            map.put(num, 1);
            // 满足情况直接返回 true 即可
            if (dfs(row + 1)) {
                return true;
            }
            status[row] = 0;
            map.remove(num);
        }
        return false;
    }

    /**
     * 获取每一行所有满足的状态
     */
    private static void getAllDfs(LinkedList<Integer> list, int col, int status, int num0, int num1, int row) {
        // 0 和 1 的个数不能超过 N / 2
        if (num0 > (N / 2) || num1 > (N / 2)) {
            return;
        }
        if (col == N) {
            // 检查不能有三个相连的 0 或者 1
            int flag0 = 0;
            int flag1 = 0;
            for (int i = 0; i < N; i++) {
                if ((status & (1 << i)) != 0) {
                    flag1 += 1;
                    flag0 = 0;
                    if (flag1 >= 3) {
                        return;
                    }
                } else {
                    flag0 += 1;
                    flag1 = 0;
                    if (flag0 >= 3) {
                        return;
                    }
                }
            }
            list.add(status);
            return;
        }
        if (board[row][col] != '_') {
            if (board[row][col] == '0') {
                getAllDfs(list, col + 1, status, num0 + 1, num1, row);
            } else {
                getAllDfs(list, col + 1, status + (1 << (N - col - 1)), num0, num1 + 1, row);
            }
        } else {
            getAllDfs(list, col + 1, status, num0 + 1, num1, row);
            getAllDfs(list, col + 1, status | (1 << (N - col - 1)), num0, num1 + 1, row);
        }
    }

    private static boolean checkCol() {
        // 利用 hashmap 检查是否有重复
        // 同时检查每一列中 1 的个数
        HashMap<Integer, Integer> hashMap = new HashMap<>();
        int[] temp = new int[N]; // 标记每个位置出现的 1 的个数
        for (int i = 0; i < N; i++) {
            if (hashMap.containsKey(status[i])) {
                return false;
            }
            hashMap.put(status[i], 1);
            for (int j = 0; j < N; j++) {
                if ((status[i] & (1 << j)) != 0) {
                    temp[j] += 1;
                }
            }
        }
        for (int i = 0; i < N; i++) {
            if (temp[i] != (N / 2)) {
                return false;
            }
        }
        return true;
    }
}
